# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import ipaddr
import socket
import hmac
import hashlib
import passlib.utils # for saslprep
import copy
import random
import operator
import platform
import time
from string import Template
from twisted.internet import reactor, protocol
from twisted.internet.task import LoopingCall
from twisted.internet.address import IPv4Address

MAGIC_COOKIE = 0x2112A442

REQUEST = 0
INDICATION = 1
SUCCESS_RESPONSE = 2
ERROR_RESPONSE = 3

BINDING = 0x001
ALLOCATE = 0x003
REFRESH = 0x004
SEND = 0x006
DATA_MSG = 0x007
CREATE_PERMISSION = 0x008
CHANNEL_BIND = 0x009

IPV4 = 1
IPV6 = 2

MAPPED_ADDRESS = 0x0001
USERNAME = 0x0006
MESSAGE_INTEGRITY = 0x0008
ERROR_CODE = 0x0009
UNKNOWN_ATTRIBUTES = 0x000A
LIFETIME = 0x000D
DATA_ATTR = 0x0013
XOR_PEER_ADDRESS = 0x0012
REALM = 0x0014
NONCE = 0x0015
XOR_RELAYED_ADDRESS = 0x0016
REQUESTED_TRANSPORT = 0x0019
DONT_FRAGMENT = 0x001A
XOR_MAPPED_ADDRESS = 0x0020
SOFTWARE = 0x8022
ALTERNATE_SERVER = 0x8023
FINGERPRINT = 0x8028

def unpack_uint(bytes_buf):
    result = 0
    for byte in bytes_buf:
        result = (result << 8) + byte
    return result

def pack_uint(value, width):
    if value < 0:
        raise ValueError("Invalid value: {}".format(value))
    buf = bytearray([0]*width)
    for i in range(0, width):
        buf[i] = (value >> (8*(width - i - 1))) & 0xFF

    return buf

def unpack(bytes_buf, format_array):
    results = ()
    for width in format_array:
        results = results + (unpack_uint(bytes_buf[0:width]),)
        bytes_buf = bytes_buf[width:]
    return results

def pack(values, format_array):
    if len(values) != len(format_array):
        raise ValueError()
    buf = bytearray()
    for i in range(0, len(values)):
        buf.extend(pack_uint(values[i], format_array[i]))
    return buf

def bitwise_pack(source, dest, start_bit, num_bits):
    if num_bits <= 0 or num_bits > start_bit + 1:
        raise ValueError("Invalid num_bits: {}, start_bit = {}"
                         .format(num_bits, start_bit))
    last_bit = start_bit - num_bits + 1
    source = source >> last_bit
    dest = dest << num_bits
    mask = (1 << num_bits) - 1
    dest += source & mask
    return dest


class StunAttribute(object):
    """
    Represents a STUN attribute in a raw format, according to the following:

     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   StunAttribute.attr_type     |  Length (derived as needed)   |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |           StunAttribute.data (variable length)             ....
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    """

    __attr_header_fmt = [2,2]
    __attr_header_size = reduce(operator.add, __attr_header_fmt)

    def __init__(self, attr_type=0, buf=bytearray()):
        self.attr_type = attr_type
        self.data = buf

    def build(self):
        buf = pack((self.attr_type, len(self.data)), self.__attr_header_fmt)
        buf.extend(self.data)
        # add padding if necessary
        if len(buf) % 4:
            buf.extend([0]*(4 - (len(buf) % 4)))
        return buf

    def parse(self, buf):
        if self.__attr_header_size  > len(buf):
            raise Exception('truncated at attribute: incomplete header')

        self.attr_type, length = unpack(buf, self.__attr_header_fmt)
        length += self.__attr_header_size

        if length > len(buf):
            raise Exception('truncated at attribute: incomplete contents')

        self.data = buf[self.__attr_header_size:length]

        # verify padding
        while length % 4:
            if buf[length]:
                raise ValueError("Non-zero padding")
            length += 1

        return length


class StunMessage(object):
    """
    Represents a STUN message. Contains a method, msg_class, cookie,
    transaction_id, and attributes (as an array of StunAttribute).

    Has various functions for getting/adding attributes.
    """

    def __init__(self):
        self.method = 0
        self.msg_class = 0
        self.cookie = MAGIC_COOKIE
        self.transaction_id = 0
        self.attributes = []

#      0                   1                   2                   3
#      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#     |0 0|M M M M M|C|M M M|C|M M M M|         Message Length        |
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#     |                         Magic Cookie                          |
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#     |                                                               |
#     |                     Transaction ID (96 bits)                  |
#     |                                                               |
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    __header_fmt = [2, 2, 4, 12]
    __header_size = reduce(operator.add, __header_fmt)

    # Returns how many bytes were parsed if buf was large enough, or how many
    # bytes we would have needed if not. Throws if buf is malformed.
    def parse(self, buf):
        min_buf_size = self.__header_size
        if len(buf) < min_buf_size:
            return min_buf_size

        message_type, length, cookie, self.transaction_id = unpack(
                buf, self.__header_fmt)
        min_buf_size += length
        if len(buf) < min_buf_size:
            return min_buf_size

        # Avert your eyes...
        self.method = bitwise_pack(message_type, 0, 13, 5)
        self.msg_class = bitwise_pack(message_type, 0, 8, 1)
        self.method = bitwise_pack(message_type, self.method, 7, 3)
        self.msg_class = bitwise_pack(message_type, self.msg_class, 4, 1)
        self.method = bitwise_pack(message_type, self.method, 3, 4)

        if cookie != self.cookie:
            raise Exception('Invalid cookie: {}'.format(cookie))

        buf = buf[self.__header_size:min_buf_size]
        while len(buf):
            attr = StunAttribute()
            length = attr.parse(buf)
            buf = buf[length:]
            self.attributes.append(attr)

        return min_buf_size

    # stop_after_attr_type is useful for calculating MESSAGE-DIGEST
    def build(self, stop_after_attr_type=0):
        attrs = bytearray()
        for attr in self.attributes:
            attrs.extend(attr.build())
            if attr.attr_type == stop_after_attr_type:
                break

        message_type = bitwise_pack(self.method, 0, 11, 5)
        message_type = bitwise_pack(self.msg_class, message_type, 1, 1)
        message_type = bitwise_pack(self.method, message_type, 6, 3)
        message_type = bitwise_pack(self.msg_class, message_type, 0, 1)
        message_type = bitwise_pack(self.method, message_type, 3, 4)

        message = pack((message_type,
                        len(attrs),
                        self.cookie,
                        self.transaction_id), self.__header_fmt)
        message.extend(attrs)

        return message

    def add_error_code(self, code, phrase=None):
#      0                   1                   2                   3
#      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#     |           Reserved, should be 0         |Class|     Number    |
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#     |      Reason Phrase (variable)                                ..
#     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        error_code_fmt = [3, 1]
        error_code = pack((code // 100, code % 100), error_code_fmt)
        if phrase != None:
            error_code.extend(bytearray(phrase))
        self.attributes.append(StunAttribute(ERROR_CODE, error_code))

#     0                   1                   2                   3
#     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
#    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#    |x x x x x x x x|    Family     |         X-Port                |
#    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#    |                X-Address (Variable)
#    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    __xor_v4addr_fmt = [1, 1, 2, 4]
    __xor_v6addr_fmt = [1, 1, 2, 16]
    __xor_v4addr_size = reduce(operator.add, __xor_v4addr_fmt)
    __xor_v6addr_size = reduce(operator.add, __xor_v6addr_fmt)

    def get_xaddr(self, ip_addr, version):
        if version == IPV4:
            return self.cookie ^ ip_addr
        elif version == IPV6:
            return ((self.cookie << 96) + self.transaction_id) ^ ip_addr
        else:
            raise ValueError("Invalid family: {}".format(family))

    def get_xport(self, port):
        return (self.cookie >> 16) ^ port

    def add_xor_address(self, addr_port, attr_type):
        ip_address = ipaddr.IPAddress(addr_port.host)
        xport = self.get_xport(addr_port.port)

        if ip_address.version == 4:
            xaddr = self.get_xaddr(int(ip_address), IPV4)
            xor_address = pack((0, IPV4, xport, xaddr), self.__xor_v4addr_fmt)
        elif ip_address.version == 6:
            xaddr = self.get_xaddr(int(ip_address), IPV6)
            xor_address = pack((0, IPV6, xport, xaddr), self.__xor_v6addr_fmt)
        else:
            raise ValueError("Invalid ip version: {}"
                             .format(ip_address.version))

        self.attributes.append(StunAttribute(attr_type, xor_address))

    def add_data(self, buf):
        self.attributes.append(StunAttribute(DATA_ATTR, buf))

    def find(self, attr_type):
        for attr in self.attributes:
            if attr.attr_type == attr_type:
                return attr
        return None

    def get_xor_address(self, attr_type):
        addr_attr = self.find(attr_type)
        if not addr_attr:
            return None

        padding, family, xport, xaddr = unpack(addr_attr.data,
                                               self.__xor_v4addr_fmt)
        addr_ctor = IPv4Address
        if family == IPV6:
            from twisted.internet.address import IPv6Address
            padding, family, xport, xaddr = unpack(addr_attr.data,
                                                   self.__xor_v6addr_fmt)
            addr_ctor = IPv6Address
        elif family != IPV4:
            raise ValueError("Invalid family: {}".format(family))

        return addr_ctor('UDP',
                         str(ipaddr.IPAddress(self.get_xaddr(xaddr, family))),
                         self.get_xport(xport))

    def add_nonce(self, nonce):
        self.attributes.append(StunAttribute(NONCE, bytearray(nonce)))

    def add_realm(self, realm):
        self.attributes.append(StunAttribute(REALM, bytearray(realm)))

    def calculate_message_digest(self, username, realm, password):
        digest_buf = self.build(MESSAGE_INTEGRITY)
        # Trim off the MESSAGE-INTEGRITY attr
        digest_buf = digest_buf[:len(digest_buf) - 24]
        password = passlib.utils.saslprep(unicode(password))
        key_string = "{}:{}:{}".format(username, realm, password)
        md5 = hashlib.md5()
        md5.update(key_string)
        key = md5.digest()
        return bytearray(hmac.new(key, digest_buf, hashlib.sha1).digest())

    def add_lifetime(self, lifetime):
        self.attributes.append(StunAttribute(LIFETIME, pack_uint(lifetime, 4)))

    def get_lifetime(self):
        lifetime_attr = self.find(LIFETIME)
        if not lifetime_attr:
            return None
        return unpack_uint(lifetime_attr.data[0:4])

    def get_username(self):
        username = self.find(USERNAME)
        if not username:
            return None
        return str(username.data)

    def add_message_integrity(self, username, realm, password):
        dummy_value = bytearray([0]*20)
        self.attributes.append(StunAttribute(MESSAGE_INTEGRITY, dummy_value))
        digest = self.calculate_message_digest(username, realm, password)
        self.find(MESSAGE_INTEGRITY).data = digest


class Allocation(protocol.DatagramProtocol):
    """
    Comprises the socket for a TURN allocation, a back-reference to the
    transport we will forward received traffic on, the allocator's address and
    username, the set of permissions for the allocation, and the allocation's
    expiry.
    """

    def __init__(self, other_transport_handler, allocator_address, username):
        self.permissions = set() # str, int tuples
        # Handler to use when sending stuff that arrives on the allocation
        self.other_transport_handler = other_transport_handler
        self.allocator_address = allocator_address
        self.username = username
        self.expiry = time.time()
        self.port = reactor.listenUDP(0, self, interface=v4_address)

    def datagramReceived(self, data, (host, port)):
        if not host in self.permissions:
            print("Dropping packet from {}:{}, no permission on allocation {}"
                  .format(host, port, self.transport.getHost()))
            return

        data_indication = StunMessage()
        data_indication.method = DATA_MSG
        data_indication.msg_class = INDICATION
        data_indication.transaction_id = random.getrandbits(96)

        # Only handles UDP allocations. Doubtful that we need more than this.
        data_indication.add_xor_address(IPv4Address('UDP', host, port),
                                        XOR_PEER_ADDRESS)
        data_indication.add_data(data)

        self.other_transport_handler.write(data_indication.build(),
                                           self.allocator_address)

    def close(self):
        self.port.stopListening()
        self.port = None


class StunHandler(object):
    """
    Frames and handles STUN messages. This is the core logic of the TURN
    server, along with Allocation.
    """

    def __init__(self, transport_handler):
        self.client_address = None
        self.data = str()
        self.transport_handler = transport_handler

    def data_received(self, data, address):
        self.data += bytearray(data)
        while True:
            stun_message = StunMessage()
            parsed_len = stun_message.parse(self.data)
            if parsed_len > len(self.data):
                break
            self.data = self.data[parsed_len:]

            response = self.handle_stun(stun_message, address)
            if response:
                self.transport_handler.write(response, address)

    def handle_stun(self, stun_message, address):
        self.client_address = address
        if stun_message.msg_class == INDICATION:
            if stun_message.method == SEND:
                self.handle_send_indication(stun_message)
            else:
                print("Dropping unknown indication method: {}"
                      .format(stun_message.method))
            return None

        if stun_message.msg_class != REQUEST:
            print("Dropping STUN response, method: {}"
                  .format(stun_message.method))
            return None

        if stun_message.method == BINDING:
            return self.make_success_response(stun_message).build()
        elif stun_message.method == ALLOCATE:
            return self.handle_allocation(stun_message).build()
        elif stun_message.method == REFRESH:
            return self.handle_refresh(stun_message).build()
        elif stun_message.method == CREATE_PERMISSION:
            return self.handle_permission(stun_message).build()
        else:
            return self.make_error_response(
                    stun_message,
                    400,
                    ("Unsupported STUN request, method: {}"
                     .format(stun_message.method))).build()

    def get_allocation_tuple(self):
        return (self.client_address.host,
                self.client_address.port,
                self.transport_handler.transport.getHost().type,
                self.transport_handler.transport.getHost().host,
                self.transport_handler.transport.getHost().port)

    def handle_allocation(self, request):
        allocate_response = self.check_long_term_auth(request)
        if allocate_response.msg_class == SUCCESS_RESPONSE:
            if self.get_allocation_tuple() in allocations:
                return self.make_error_response(
                        request,
                        437,
                        ("Duplicate allocation request for tuple {}"
                         .format(self.get_allocation_tuple())))

            allocation = Allocation(self.transport_handler,
                                    self.client_address,
                                    request.get_username())

            allocate_response.add_xor_address(allocation.transport.getHost(),
                                              XOR_RELAYED_ADDRESS)

            lifetime = request.get_lifetime()
            if lifetime == None:
                return self.make_error_response(
                        request,
                        400,
                        "Missing lifetime attribute in allocation request")

            lifetime = min(lifetime, 3600)
            allocate_response.add_lifetime(lifetime)
            allocation.expiry = time.time() + lifetime

            allocate_response.add_message_integrity(turn_user,
                                                    turn_realm,
                                                    turn_pass)
            allocations[self.get_allocation_tuple()] = allocation
        return allocate_response

    def handle_refresh(self, request):
        refresh_response = self.check_long_term_auth(request)
        if refresh_response.msg_class == SUCCESS_RESPONSE:
            try:
                allocation = allocations[self.get_allocation_tuple()]
            except KeyError:
                return self.make_error_response(
                        request,
                        437,
                        ("Refresh request for non-existing allocation, tuple {}"
                         .format(self.get_allocation_tuple())))

            if allocation.username != request.get_username():
                return self.make_error_response(
                        request,
                        441,
                        ("Refresh request with wrong user, exp {}, got {}"
                         .format(allocation.username, request.get_username())))

            lifetime = request.get_lifetime()
            if lifetime == None:
                return self.make_error_response(
                        request,
                        400,
                        "Missing lifetime attribute in allocation request")

            lifetime = min(lifetime, 3600)
            refresh_response.add_lifetime(lifetime)
            allocation.expiry = time.time() + lifetime

            refresh_response.add_message_integrity(turn_user,
                                                   turn_realm,
                                                   turn_pass)
        return refresh_response

    def handle_permission(self, request):
        permission_response = self.check_long_term_auth(request)
        if permission_response.msg_class == SUCCESS_RESPONSE:
            try:
                allocation = allocations[self.get_allocation_tuple()]
            except KeyError:
                return self.make_error_response(
                        request,
                        437,
                        ("No such allocation for permission request, tuple {}"
                         .format(self.get_allocation_tuple())))

            if allocation.username != request.get_username():
                return self.make_error_response(
                        request,
                        441,
                        ("Permission request with wrong user, exp {}, got {}"
                         .format(allocation.username, request.get_username())))

            # TODO: Handle multiple XOR-PEER-ADDRESS
            peer_address = request.get_xor_address(XOR_PEER_ADDRESS)
            if not peer_address:
                return self.make_error_response(
                        request,
                        400,
                        "Missing XOR-PEER-ADDRESS on permission request")

            permission_response.add_message_integrity(turn_user,
                                                      turn_realm,
                                                      turn_pass)
            allocation.permissions.add(peer_address.host)

        return permission_response

    def handle_send_indication(self, indication):
        try:
            allocation = allocations[self.get_allocation_tuple()]
        except KeyError:
            print("Dropping send indication; no allocation for tuple {}"
                  .format(self.get_allocation_tuple()))
            return

        peer_address = indication.get_xor_address(XOR_PEER_ADDRESS)
        if not peer_address:
            print("Dropping send indication, missing XOR-PEER-ADDRESS")
            return

        data_attr = indication.find(DATA_ATTR)
        if not data_attr:
            print("Dropping send indication, missing DATA")
            return

        if indication.find(DONT_FRAGMENT):
            print("Dropping send indication, DONT-FRAGMENT set")
            return

        if not peer_address.host in allocation.permissions:
            print("Dropping send indication, no permission for {} on tuple {}"
                  .format(peer_address.host, self.get_allocation_tuple()))
            return

        allocation.transport.write(data_attr.data,
                                   (peer_address.host, peer_address.port))

    def make_success_response(self, request):
        response = copy.deepcopy(request)
        response.attributes = []
        response.add_xor_address(self.client_address, XOR_MAPPED_ADDRESS)
        response.msg_class = SUCCESS_RESPONSE
        return response

    def make_error_response(self, request, code, reason=None):
        if reason:
            print("{}: rejecting with {}".format(reason, code))
        response = copy.deepcopy(request)
        response.attributes = []
        response.add_error_code(code, reason)
        response.msg_class = ERROR_RESPONSE
        return response

    def make_challenge_response(self, request, reason=None):
        response = self.make_error_response(request, 401, reason)
        # 65 means the hex encoding will need padding half the time
        response.add_nonce("{:x}".format(random.getrandbits(65)))
        response.add_realm(turn_realm)
        return response

    def check_long_term_auth(self, request):
        message_integrity = request.find(MESSAGE_INTEGRITY)
        if not message_integrity:
            return self.make_challenge_response(request)

        username = request.find(USERNAME)
        realm = request.find(REALM)
        nonce = request.find(NONCE)
        if not username or not realm or not nonce:
            return self.make_error_response(
                    request,
                    400,
                    "Missing either USERNAME, NONCE, or REALM")

        if str(username.data) != turn_user:
            return self.make_challenge_response(
                    request,
                    "Wrong user {}, exp {}".format(username.data, turn_user))

        expected_message_digest = request.calculate_message_digest(turn_user,
                                                                  turn_realm,
                                                                  turn_pass)
        if message_integrity.data != expected_message_digest:
            return self.make_challenge_response(request,
                                                "Incorrect message disgest")

        return self.make_success_response(request)


class UdpStunHandler(protocol.DatagramProtocol):
    """
    Represents a UDP listen port for TURN.
    """

    def datagramReceived(self, data, address):
        stun_handler = StunHandler(self)
        stun_handler.data_received(data,
                                   IPv4Address('UDP', address[0], address[1]))

    def write(self, data, address):
        self.transport.write(str(data), (address.host, address.port))


class TcpStunHandlerFactory(protocol.Factory):
    """
    Represents a TCP listen port for TURN.
    """

    def buildProtocol(self, addr):
        return TcpStunHandler(addr)


class TcpStunHandler(protocol.Protocol):
    """
    Represents a connected TCP port for TURN.
    """

    def __init__(self, addr):
        self.address = addr
        self.stun_handler = None

    def dataReceived(self, data):
        # This needs to persist, since it handles framing
        if not self.stun_handler:
            self.stun_handler = StunHandler(self)
        self.stun_handler.data_received(data, self.address)

    def connectionLost(self, reason):
        print("Lost connection from {}".format(self.address))
        # Destroy allocations that this connection made
        for key, allocation in allocations.items():
            if allocation.other_transport_handler == self:
                print("Closing allocation due to dropped connection: {}"
                      .format(key))
                del allocations[key]
                allocation.close()

    def write(self, data, address):
        self.transport.write(str(data))

def get_default_route(family):
    dummy_socket = socket.socket(family, socket.SOCK_DGRAM)
    if family is socket.AF_INET:
        dummy_socket.connect(("8.8.8.8", 53))
    else:
        dummy_socket.connect(("2001:4860:4860::8888", 53))

    default_route = dummy_socket.getsockname()[0]
    dummy_socket.close()
    return default_route

turn_user="foo"
turn_pass="bar"
turn_realm="mozilla.invalid"
allocations = {}
v4_address = get_default_route(socket.AF_INET)
try:
    v6_address = get_default_route(socket.AF_INET6)
except:
    v6_address = ""

def prune_allocations():
    now = time.time()
    for key, allocation in allocations.items():
        if allocation.expiry < now:
            print("Allocation expired: {}".format(key))
            del allocations[key]
            allocation.close()

if __name__ == "__main__":
    random.seed()

    if platform.system() is "Windows":
      # Windows is finicky about allowing real interfaces to talk to loopback.
      interface_4 = v4_address
      interface_6 = v6_address
      hostname = socket.gethostname()
    else:
      # Our linux builders do not have a hostname that resolves to the real
      # interface.
      interface_4 = "127.0.0.1"
      interface_6 = "::1"
      hostname = "localhost"

    reactor.listenUDP(3478, UdpStunHandler(), interface=interface_4)
    reactor.listenTCP(3478, TcpStunHandlerFactory(), interface=interface_4)

    try:
        reactor.listenUDP(3478, UdpStunHandler(), interface=interface_6)
        reactor.listenTCP(3478, TcpStunHandlerFactory(), interface=interface_6)
    except:
        pass

    allocation_pruner = LoopingCall(prune_allocations)
    allocation_pruner.start(1)

    template = Template(
'[\
{"url":"stun:$hostname"}, \
{"url":"stun:$hostname?transport=tcp"}, \
{"username":"$user","credential":"$pwd","url":"turn:$hostname"}, \
{"username":"$user","credential":"$pwd","url":"turn:$hostname?transport=tcp"}]'
)

    print(template.substitute(user=turn_user,
                              pwd=turn_pass,
                              hostname=hostname))

    reactor.run()

